////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxsensordriver.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXSENSORDRIVER_H
#define CAMXSENSORDRIVER_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "camxsensorcommon.h"

#define CAMX_NAMESPACE_BEGIN namespace CamX {
#define CAMX_NAMESPACE_END }

CAMX_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SlaveInformation
/// Comments:      Sensor slave information
///                 element for sensorName
///                 element for slaveAddress
///                 element for regAddrType
///                 element for regDataType
///                 element for sensorIdRegAddr
///                 element for sensorId
///                 element for sensorIdMask
///                 element for i2cFrequencyMode
///                 element for powerUpSequence
///                 element for powerDownSequence
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SlaveInformation
{
    /// Name of the sensor
    CHAR*                                sensorName;
    /// 8-bit or 10-bit write slave address
    /// For External Sensors for which camx needs not probe the slave address shoule be as 0
    UINT32                               slaveAddress;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regAddrType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regDataType
    ///
    /// Range:         [1,4]
    /// Comments:      Register address / data size in bytes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CRegAddrDataType regDataType;
    /// Register address for sensor Id
    UINT32                               sensorIdRegAddr;
    /// Sensor Id
    UINT32                               sensorId;
    /// Mask for sensor id. Sensor Id may only be few bits
    UINT32                               sensorIdMask;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// i2cFrequencyMode
    /// Default Value: FAST_PLUS
    /// Comments:      I2C frequency mode of slave
    ///                Supported modes are: STANDARD (100 KHz), FAST (400 KHz), FAST_PLUS (1 MHz), CUSTOM (Custom frequency in
    ///                DTSI)
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    I2CFrequencyMode   i2cFrequencyMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// powerUpSequence
    /// Comments:      Sequence of power configuration type and configuration value required to control power to the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PowerSequenceInfo  powerUpSequence;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// powerDownSequence
    /// Comments:      Sequence of power configuration type and configuration value required to control power to the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PowerSequenceInfo  powerDownSequence;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// RegAddrInformation
/// Comments:      Addresses for various sensor registers
///                 element for xOutput
///                 element for yOutput
///                 element for frameLengthLines
///                 element for lineLengthPixelClock
///                 element for coarseIntgTimeAddr
///                 element for shortCoarseIntgTimeAddr
///                 element for analog globalGainAddr
///                 element for analog shortGlobalGainAddr
///                 element for digitalGlobalGainAddr
///                 element for digitalGainRedAddr
///                 element for digitalGainGreenRedAddr
///                 element for digitalGainBlueAddr
///                 element for digitalGainGreenBlueAddr
///                 element for testPatternRAddr
///                 element for testPatternGRAddr
///                 element for testPatternBAddr
///                 element for testPatternGBAddr
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct RegAddrInformation
{
    /// Register address to program width
    UINT32  xOutput;
    /// Register address to program height
    UINT32  yOutput;
    /// Register address to program Frame length lines
    UINT32  frameLengthLines;
    /// Register address to program Line length pixel clock
    UINT32  lineLengthPixelClock;
    /// Register address to program coarse integration time
    UINT32  coarseIntgTimeAddr;
    /// Register address to program short coarse integration time
    /// This address is optional and must be provided if supported by sensor
    UINT32  shortCoarseIntgTimeAddrExists;
    UINT32  shortCoarseIntgTimeAddrID;
    UINT32  shortCoarseIntgTimeAddr;
    /// Register address to program analog global gain channel
    UINT32  globalGainAddr;
    /// Register address to program short global analog gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  shortGlobalGainAddrExists;
    UINT32  shortGlobalGainAddrID;
    UINT32  shortGlobalGainAddr;
    /// Register address to program digital gloabl gain channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  digitalGlobalGainAddrExists;
    UINT32  digitalGlobalGainAddrID;
    UINT32  digitalGlobalGainAddr;
    /// Register address to program digital gain for Red channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  digitalGainRedAddrExists;
    UINT32  digitalGainRedAddrID;
    UINT32  digitalGainRedAddr;
    /// Register address to program digital gain for green red channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  digitalGainGreenRedAddrExists;
    UINT32  digitalGainGreenRedAddrID;
    UINT32  digitalGainGreenRedAddr;
    /// Register address to program digital gain for blue channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  digitalGainBlueAddrExists;
    UINT32  digitalGainBlueAddrID;
    UINT32  digitalGainBlueAddr;
    /// Register address to program digital gain for green blue channel
    /// This address is optional and must be provided if supported by sensor
    UINT32  digitalGainGreenBlueAddrExists;
    UINT32  digitalGainGreenBlueAddrID;
    UINT32  digitalGainGreenBlueAddr;
    /// Register address to program manual test pattern value for Red channel
    UINT32  testPatternRAddr;
    /// Register address to program manual test pattern value for Green Red channel
    UINT32  testPatternGRAddr;
    /// Register address to program manual test pattern value for Blue channel
    UINT32  testPatternBAddr;
    /// Register address to program manual test pattern value for Green Blue channel
    UINT32  testPatternGBAddr;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ColorFilterArrangement
/// Comments:      Color filter arrangement of the sensor
///                Supported filter arrangements are: BAYER_BGGR, BAYER_GBRG, BAYER_GRBG, BAYER_RGGB, BAYER_Y, YUV_UYVY,
///                YUV_YUYV
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ColorFilterArrangement
{
    BAYER_BGGR = 0,
    BAYER_GBRG = 1,
    BAYER_GRBG = 2,
    BAYER_RGGB = 3,
    BAYER_Y    = 4,
    YUV_UYVY   = 5,
    YUV_YUYV   = 6
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// VirtualChannel
///
/// Range:         [0,3]
/// Comments:      Virtual Channel of the data
///                Valid values for virtual channel are: 0, 1, 2 and 3
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef UINT32 VirtualChannel;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// IntegrationInfo
/// Comments:      Intergation related information for each resolution
///                 element for integrationTimeMin
///                 element for integrationTimeStep
///                 element for integrationTimeMargin
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct IntegrationInfo
{
    /// Minimum intergation time
    UINT32 integrationTimeMin;
    /// The step of intergation time
    UINT32 integrationTimeStep;
    /// Integration time margin
    UINT32 integrationTimeMargin;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamType
/// Comments:      Type of the stream
///                Supported stream types are: BLOB, IMAGE, PDAF, HDR, META
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class StreamType
{
    BLOB  = 0,
    IMAGE = 1,
    PDAF  = 2,
    HDR   = 3,
    META  = 4
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamConfiguration
/// Comments:      Information for a stream data
///                 element for vc
///                 element for dt
///                 element for dimension
///                 element for bitWidth
///                 element for type
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StreamConfiguration
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// vc
    ///
    /// Default Value: 0
    /// Range:         [0,3]
    /// Comments:      Virtual Channel of the data
    ///                Valid values for virtual channel are: 0, 1, 2 and 3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VirtualChannel                   vc;
    /// Data type of the stream. Default value is 0x2B (10-bit RAW)
    UINT32                           dt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDimension
    /// Comments:      Frame dimension: contains xStart, yStart, width and height
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FrameDimension frameDimension;
    /// Bit width of the data
    UINT32                           bitWidth;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// type
    /// Default Value: IMAGE
    /// Comments:      Type of the stream
    ///                Supported stream types are: BLOB, IMAGE, PDAF, HDR, META
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StreamType                       type;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// StreamInformation
/// Comments:      Stream information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StreamInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamConfiguration - Array
    /// Min Length:    1
    /// Max Length:    4
    /// Comments:      Information for a stream data
    ///                 element for vc
    ///                 element for dt
    ///                 element for dimension
    ///                 element for bitWidth
    ///                 element for type
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32               streamConfigurationCount;
    UINT32               streamConfigurationID;
    StreamConfiguration* streamConfiguration;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorCapability
/// Comments:      Capability / features supported in sensor
///                Supported features are: NORMAL, HFR, IHDR, PDAF, QUADCFA, ZZHDR, FASTAEC
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensorCapability
{
    NORMAL  = 0,
    HFR     = 1,
    IHDR    = 2,
    PDAF    = 3,
    QUADCFA = 4,
    ZZHDR   = 5,
    FASTAEC = 6,
    DEPTH   = 7
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorCapabilityList - Array
/// Min Length:    1
/// Max Length:    2147483647
/// Comments:      List of features / capabilities supported by sensor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef SensorCapability* SensorCapabilityList;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRColorPattern
/// Comments:      This 2 bit value represents the bayer starting R1.
///                Supported patterns are: R1G1G2B1, R1G1G2B2, R1G2G1B1, R1G2G1B2
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ZZHDRColorPattern
{
    R1G1G2B1 = 0,
    R1G1G2B2 = 1,
    R1G2G1B1 = 2,
    R1G2G1B2 = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRFirstExposurePattern
/// Comments:      This value represents whether short exposure or long exposure field comes first.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class ZZHDRFirstExposurePattern
{
    SHORTEXPOSURE = 0,
    LONGEXPOSURE  = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// BorderInformation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct BorderInformation
{
    UINT32 left;
    UINT32 right;
    UINT32 top;
    UINT32 bottom;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ZZHDRInformation
/// Comments:      ZZHDR color pattern and first exposure information
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ZZHDRInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRPattern - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This 2 bit value represents the bayer starting R1.
    ///                Supported patterns are: R1G1G2B1, R1G1G2B2, R1G2G1B1, R1G2G1B2
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                     ZZHDRPatternExists;
    UINT32                     ZZHDRPatternID;
    ZZHDRColorPattern          ZZHDRPattern;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRFirstExposure - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      This value represents whether short exposure or long exposure field comes first.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                     ZZHDRFirstExposureExists;
    UINT32                     ZZHDRFirstExposureID;
    ZZHDRFirstExposurePattern  ZZHDRFirstExposure;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ResolutionData
/// Comments:       element for colorFilterArrangement
///                 element for streamInfo
///                 element for lineLengthPixelClock
///                 element for frameLengthLines
///                 element for minHorizontalBlanking
///                 element for minVerticalBlanking
///                 element for outputPixelClock
///                 element for horizontalBinning
///                 element for verticalBinning
///                 element for frameRate
///                 element for laneCount
///                 element for downScaleFactor
///                 element for settleTimeNs
///                 element for is3Phase
///                 element for integrationInfo
///                 element for resSettings
///                 element for cropInfo
///                 element for ZZHDR Information
///                 element for capability
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ResolutionData
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// colorFilterArrangement
    /// Comments:      Color filter arrangement of the sensor
    ///                Supported filter arrangements are: BAYER_BGGR, BAYER_GBRG, BAYER_GRBG, BAYER_RGGB, BAYER_Y, YUV_UYVY,
    ///                YUV_YUYV
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ColorFilterArrangement         colorFilterArrangement;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamInfo
    /// Comments:      Stream information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    StreamInformation              streamInfo;
    /// Line length pixel clock of frame
    /// Typically this value is the active width + blanking width
    UINT32                         lineLengthPixelClock;
    /// Frame length lines of frame
    /// Typically this value is the active height + blanking height
    UINT32                         frameLengthLines;
    /// Minimum horizontal blanking interval in pixels
    UINT32                         minHorizontalBlanking;
    /// Minimum horizontal blanking interval in lines
    UINT32                         minVerticalBlanking;
    /// Output pixel clock
    UINT32                         outputPixelClock;
    /// Horizontal binning value
    UINT32                         horizontalBinning;
    /// Vertical binning value
    UINT32                         verticalBinning;
    /// Maximum frame rate
    DOUBLE                         frameRate;
    /// Number of lanes in which the data is streamed
    UINT32                         laneCount;
    /// The value is a ratio, and the sensors are able only to downscale.
    /// It must be 1.00 or greater at all times.
    UINT32                         downScaleFactorExists;
    UINT32                         downScaleFactorID;
    FLOAT                          downScaleFactor;
    /// Settle time in nano seconds
    UINT32                         settleTimeNs;
    /// Flag to know if the sensor is a 3phase sensor
    UINT32                         is3Phase;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// integrationInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Intergation related information for each resolution
    ///                 element for integrationTimeMin
    ///                 element for integrationTimeStep
    ///                 element for integrationTimeMargin
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                         integrationInfoExists;
    UINT32                         integrationInfoID;
    IntegrationInfo                integrationInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo resSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// cropInfo
    /// Comments:      Crop information for the frame
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BorderInformation              cropInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ZZHDRInfo - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      ZZHDR color pattern and first exposure information
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                         ZZHDRInfoExists;
    UINT32                         ZZHDRInfoID;
    ZZHDRInformation               ZZHDRInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// capability - Array
    /// Min Length:    1
    /// Max Length:    2147483647
    /// Comments:      List of features / capabilities supported by sensor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                         capabilityCount;
    UINT32                         capabilityID;
    SensorCapabilityList           capability;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ResolutionInformation
/// Comments:      Information of all the resolutions
///                Number of resolutions is detected from number of resolutionData nodes
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ResolutionInformation
{
    UINT32          sensorVersion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resolutionData - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:       element for colorFilterArrangement
    ///                 element for streamInfo
    ///                 element for lineLengthPixelClock
    ///                 element for frameLengthLines
    ///                 element for minHorizontalBlanking
    ///                 element for minVerticalBlanking
    ///                 element for outputPixelClock
    ///                 element for horizontalBinning
    ///                 element for verticalBinning
    ///                 element for frameRate
    ///                 element for laneCount
    ///                 element for downScaleFactor
    ///                 element for settleTimeNs
    ///                 element for is3Phase
    ///                 element for integrationInfo
    ///                 element for resSettings
    ///                 element for cropInfo
    ///                 element for ZZHDR Information
    ///                 element for capability
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32          resolutionDataCount;
    UINT32          resolutionDataID;
    ResolutionData* resolutionData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// InitSettings
/// Comments:      Information of the initial settings
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct InitSettings
{
    UINT32                         sensorVersion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initSetting
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo initSetting;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ExposureContorlInformation
/// Comments:      Exposure control information
///                 element for maxAnalogGain
///                 element for maxDigitalGain
///                 element for verticalOffset
///                 element for verticalOffset
///                 element for realToRegDigitalGainConversionFactor
///                 element for analog realToRegGain
///                 element for analog regToRealGain
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ExposureContorlInformation
{
    /// Maximum analog again supported by sensor
    DOUBLE maxAnalogGain;
    /// Maximum digital again supported by sensor
    DOUBLE maxDigitalGain;
    /// Minimum offset to be maintained between line count and frame length lines
    UINT32 verticalOffset;
    /// Maximum line count supported by sensor
    UINT32 maxLineCount;
    /// Conversion factor to convert real digital gain to register digital gain
    DOUBLE realToRegDigitalGainConversionFactor;
    /// Real analog gain to register analog gain equation
    /// The equation must contain "realGain" in its equation
    /// Ex:= 512 - (512 / realGain)
    CHAR*  realToRegGain;
    /// analog Register gain to real gain equation
    /// The equation must contain "regGain" in its equation
    /// Ex:= 512 / (512 - regGain)
    CHAR*  regToRealGain;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternMode
/// Comments:      Test pattern mode
///                Supported modes are: OFF, SOLID_COLOR, COLOR_BARS, COLOR_BARS_FADE_TO_GRAY, PN9, CUSTOM1
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class TestPatternMode
{
    OFF                     = 0,
    SOLID_COLOR             = 1,
    COLOR_BARS              = 2,
    COLOR_BARS_FADE_TO_GRAY = 3,
    PN9                     = 4,
    CUSTOM1                 = 5
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternData
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TestPatternData
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// mode
    /// Comments:      Test pattern mode
    ///                Supported modes are: OFF, SOLID_COLOR, COLOR_BARS, COLOR_BARS_FADE_TO_GRAY, PN9, CUSTOM1
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TestPatternMode                mode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// settings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo settings;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TestPatternInformation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct TestPatternInformation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// testPatternData - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32           testPatternDataCount;
    UINT32           testPatternDataID;
    TestPatternData* testPatternData;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// ColorLevelInformation
/// Comments:      Color level information
///                These are the default currents in various channels in complete dark light
///                 element for whiteLevel
///                 element for rPedestal
///                 element for grPedestal
///                 element for bPedestal
///                 element for gbPedestal
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct ColorLevelInformation
{
    /// White level value
    UINT32 whiteLevel;
    /// Pedestal value for Red channel
    UINT32 rPedestal;
    /// Pedestal value for GreenRed channel
    UINT32 grPedestal;
    /// Pedestal value for Blue channel
    UINT32 bPedestal;
    /// Pedestal value for Green Blue channel
    UINT32 gbPedestal;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// OpticalBlackRegionInfo
/// Comments:      Information about black regions
///                Multiple black regions can be provided if applicable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct OpticalBlackRegionInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dimension - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Frame dimension: contains xStart, yStart, width and height
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                            dimensionCount;
    UINT32                            dimensionID;
    FrameDimension* dimension;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// PixelArrayInfo
/// Comments:      Information about the pixel array
///                Active dimension and dummy pixels width are provided
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct PixelArrayInfo
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// activeDimension
    /// Comments:      Width and height of the frame or subframe
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    Dimension activeDimension;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dummyInfo
    /// Comments:      Dummy pixels surrounding the active pixel array
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BorderInformation           dummyInfo;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// DelayInfo
/// Comments:      Application delay information
///                 element for linecount
///                 element for gain
///                 element for maxPipelineDelay
///                 element for frameSkip
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct DelayInfo
{
    /// Number of frames required to apply the linecount
    UINT32 linecount;
    /// Number of frames required to apply the gain
    UINT32 gain;
    /// Maximum pipeline delay in number of frames
    UINT32 maxPipeline;
    /// Number of initial bad frames to skip
    UINT32 frameSkip;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensingMethod
/// Comments:      Sensing method of senosor
///                Supported sensing methods: UNDEFINED, ONE_CHIP_COLOR_AREA, TWO_CHIP_COLOR_AREA
///                THREE_CHIP_COLOR_AREA, COLOR_SEQUENCE_AREA, TRILINEAR, COLOR_SEQUENCE_LINEAR
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class SensingMethod
{
    UNDEFINED             = 0,
    ONE_CHIP_COLOR_AREA   = 1,
    TWO_CHIP_COLOR_AREA   = 2,
    THREE_CHIP_COLOR_AREA = 3,
    COLOR_SEQUENCE_AREA   = 4,
    TRILINEAR             = 5,
    COLOR_SEQUENCE_LINEAR = 6
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorProperty
/// Comments:       element for pixelSize
///                 element for cropFactor
///                 element for sensingMethod
///                 element for ADCReadoutTime
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SensorProperty
{
    /// Pixel size in micro meters
    DOUBLE        pixelSize;
    /// Crop factor
    DOUBLE        cropFactor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensingMethod
    /// Comments:      Sensing method of senosor
    ///                Supported sensing methods: UNDEFINED, ONE_CHIP_COLOR_AREA, TWO_CHIP_COLOR_AREA
    ///                THREE_CHIP_COLOR_AREA, COLOR_SEQUENCE_AREA, TRILINEAR, COLOR_SEQUENCE_LINEAR
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensingMethod sensingMethod;
    /// Analog to digital conversion time for the sensor. Time specified in milliseconds
    DOUBLE        ADCReadoutTime;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// NoiseCoefficent
/// Comments:       element for gradient_S
///                 element for offset_S
///                 element for gradient_O
///                 element for offset_O
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct NoiseCoefficent
{
    /// gradient_s Sensor amplification
    DOUBLE gradient_S;
    /// offset_S Sensor amplification
    DOUBLE offset_S;
    /// gradient_O sensor readout noise
    DOUBLE gradient_O;
    /// offset_O sensor readout noise
    DOUBLE offset_O;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorDriverData
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SensorDriverData
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
        INT32 incr_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// slaveInfo
    /// Comments:      Sensor slave information
    ///                 element for sensorName
    ///                 element for slaveAddress
    ///                 element for regAddrType
    ///                 element for regDataType
    ///                 element for sensorIdRegAddr
    ///                 element for sensorId
    ///                 element for sensorIdMask
    ///                 element for i2cFrequencyMode
    ///                 element for powerUpSequence
    ///                 element for powerDownSequence
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SlaveInformation                slaveInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// regAddrInfo
    /// Comments:      Addresses for various sensor registers
    ///                 element for xOutput
    ///                 element for yOutput
    ///                 element for frameLengthLines
    ///                 element for lineLengthPixelClock
    ///                 element for coarseIntgTimeAddr
    ///                 element for shortCoarseIntgTimeAddr
    ///                 element for analog globalGainAddr
    ///                 element for analog shortGlobalGainAddr
    ///                 element for digitalGlobalGainAddr
    ///                 element for digitalGainRedAddr
    ///                 element for digitalGainGreenRedAddr
    ///                 element for digitalGainBlueAddr
    ///                 element for digitalGainGreenBlueAddr
    ///                 element for testPatternRAddr
    ///                 element for testPatternGRAddr
    ///                 element for testPatternBAddr
    ///                 element for testPatternGBAddr
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    RegAddrInformation              regAddrInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// resolutionInfo - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Information of all the resolutions
    ///                Number of resolutions is detected from number of resolutionData nodes
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          resolutionInfoCount;
    UINT32                          resolutionInfoID;
    ResolutionInformation*          resolutionInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureControlInfo
    /// Comments:      Exposure control information
    ///                 element for maxAnalogGain
    ///                 element for maxDigitalGain
    ///                 element for verticalOffset
    ///                 element for verticalOffset
    ///                 element for realToRegDigitalGainConversionFactor
    ///                 element for analog realToRegGain
    ///                 element for analog regToRealGain
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ExposureContorlInformation      exposureControlInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOnSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  streamOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// streamOffSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  streamOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOnSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  groupHoldOnSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// groupHoldOffSettings
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsInfo  groupHoldOffSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// masterSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          masterSettingsExists;
    UINT32                          masterSettingsID;
    SettingsInfo  masterSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// slaveSettings - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:      Sequence of register settings to configure the device
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          slaveSettingsExists;
    UINT32                          slaveSettingsID;
    SettingsInfo  slaveSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initSettings - Array
    /// Min Length:    1
    /// Max Length:    Unbounded
    /// Comments:      Information of the initial settings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          initSettingsCount;
    UINT32                          initSettingsID;
    InitSettings*                   initSettings;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// testPatternInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    TestPatternInformation          testPatternInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// colorLevelInfo
    /// Comments:      Color level information
    ///                These are the default currents in various channels in complete dark light
    ///                 element for whiteLevel
    ///                 element for rPedestal
    ///                 element for grPedestal
    ///                 element for bPedestal
    ///                 element for gbPedestal
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ColorLevelInformation           colorLevelInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// opticalBlackRegionInfo
    /// Comments:      Information about black regions
    ///                Multiple black regions can be provided if applicable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    OpticalBlackRegionInfo          opticalBlackRegionInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// pixelArrayInfo
    /// Comments:      Information about the pixel array
    ///                Active dimension and dummy pixels width are provided
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    PixelArrayInfo                  pixelArrayInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// delayInfo
    /// Comments:      Application delay information
    ///                 element for linecount
    ///                 element for gain
    ///                 element for maxPipelineDelay
    ///                 element for frameSkip
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    DelayInfo                       delayInfo;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensorProperty
    /// Comments:       element for pixelSize
    ///                 element for cropFactor
    ///                 element for sensingMethod
    ///                 element for ADCReadoutTime
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorProperty                  sensorProperty;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// noiseCoefficent - Optional
    /// Min Length:    0
    /// Max Length:    1
    /// Comments:       element for gradient_S
    ///                 element for offset_S
    ///                 element for gradient_O
    ///                 element for offset_O
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                          noiseCoefficentExists;
    UINT32                          noiseCoefficentID;
    NoiseCoefficent                 noiseCoefficent;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// SensorDriverDataClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class SensorDriverDataClass : public ParameterModule, public SensorDriverData
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 1;
    static const UINT16 MINOR = 0;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorDriverDataClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SensorDriverDataClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~SensorDriverDataClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SlaveInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSlaveInformation(
        ParameterFileSymbolTableEntry* entry,
        SlaveInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load RegAddrInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadRegAddrInformation(
        ParameterFileSymbolTableEntry* entry,
        RegAddrInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load IntegrationInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadIntegrationInfo(
        ParameterFileSymbolTableEntry* entry,
        IntegrationInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load StreamConfiguration
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadStreamConfiguration(
        ParameterFileSymbolTableEntry* entry,
        StreamConfiguration* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load StreamInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadStreamInformation(
        ParameterFileSymbolTableEntry* entry,
        StreamInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load BorderInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadBorderInformation(
        ParameterFileSymbolTableEntry* entry,
        BorderInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ZZHDRInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadZZHDRInformation(
        ParameterFileSymbolTableEntry* entry,
        ZZHDRInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ResolutionData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadResolutionData(
        ParameterFileSymbolTableEntry* entry,
        ResolutionData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ResolutionInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadResolutionInformation(
        ParameterFileSymbolTableEntry* entry,
        ResolutionInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load InitSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadInitSettings(
        ParameterFileSymbolTableEntry* entry,
        InitSettings* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ExposureContorlInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadExposureContorlInformation(
        ParameterFileSymbolTableEntry* entry,
        ExposureContorlInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load TestPatternData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadTestPatternData(
        ParameterFileSymbolTableEntry* entry,
        TestPatternData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load TestPatternInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadTestPatternInformation(
        ParameterFileSymbolTableEntry* entry,
        TestPatternInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load ColorLevelInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadColorLevelInformation(
        ParameterFileSymbolTableEntry* entry,
        ColorLevelInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load OpticalBlackRegionInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadOpticalBlackRegionInfo(
        ParameterFileSymbolTableEntry* entry,
        OpticalBlackRegionInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load PixelArrayInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadPixelArrayInfo(
        ParameterFileSymbolTableEntry* entry,
        PixelArrayInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load DelayInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadDelayInfo(
        ParameterFileSymbolTableEntry* entry,
        DelayInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SensorProperty
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSensorProperty(
        ParameterFileSymbolTableEntry* entry,
        SensorProperty* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load NoiseCoefficent
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadNoiseCoefficent(
        ParameterFileSymbolTableEntry* entry,
        NoiseCoefficent* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load SensorDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadSensorDriverData(
        ParameterFileSymbolTableEntry* entry,
        SensorDriverData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        SensorDriverData::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload SlaveInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadSlaveInformation(
        SlaveInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload StreamInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadStreamInformation(
        StreamInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload ResolutionData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadResolutionData(
        ResolutionData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload ResolutionInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadResolutionInformation(
        ResolutionInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload InitSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadInitSettings(
        InitSettings* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload ExposureContorlInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadExposureContorlInformation(
        ExposureContorlInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload TestPatternData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadTestPatternData(
        TestPatternData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload TestPatternInformation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadTestPatternInformation(
        TestPatternInformation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload OpticalBlackRegionInfo
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadOpticalBlackRegionInfo(
        OpticalBlackRegionInfo* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload SensorDriverData
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadSensorDriverData(
        SensorDriverData* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class SensorDriverDataClass

CAMX_NAMESPACE_END
#endif // CAMXSENSORDRIVER_H

